跳到主要内容

GMP 模型-G 的数据结构

G 的数据结构概述​

在 Go 语言的 GMP 调度模型中，G（Goroutine）是执行的基本单元。每个 G 都对应一个用户级协程，由 Go 运行时管理。理解 G 的数据结构对于深入掌握 Go 的并发调度机制至关重要。

G 结构体的核心字段​

G 的数据结构在 runtime/runtime2.go 中定义，包含了 goroutine 运行所需的所有信息：

type g struct {
    // 栈信息
    stack       stack   // 栈的边界信息
    stackguard0 uintptr // 栈溢出检查点
    stackguard1 uintptr // 抢占调度检查点
    
    // 调度相关
    _panic       *_panic // panic 链表
    _defer       *_defer // defer 链表
    m            *m      // 当前绑定的 M
    sched        gobuf   // 调度上下文
    syscallsp    uintptr // 系统调用栈指针
    syscallpc    uintptr // 系统调用程序计数器
    
    // 状态和标识
    atomicstatus uint32 // G 的状态
    goid         int64  // goroutine ID
    schedlink    guintptr // 调度链表中的下一个 G
    
    // 抢占和垃圾回收
    preempt       bool    // 抢占标志
    preemptStop   bool    // 停止标志
    preemptShrink bool    // 栈收缩标志
    gcscandone    bool    // GC 扫描完成标志
    
    // 其他信息
    lockedm       muintptr // 锁定的 M
    sig           uint32   // 信号
    writebuf      []byte   // 写缓冲区
    sigcode0      uintptr  // 信号代码
    sigcode1      uintptr  // 信号代码
    sigpc         uintptr  // 信号程序计数器
    gopc          uintptr  // 创建此 goroutine 的 PC
    startpc       uintptr  // goroutine 函数的 PC
}

栈管理字段详解​

栈字段的作用：

type stack struct {
    lo uintptr // 栈的低地址（栈底）
    hi uintptr // 栈的高地址（栈顶）
}

// 栈溢出检查示例
func checkStackOverflow(g *g) {
    // stackguard0 = stack.lo + StackGuard
    if g.stack.lo + StackGuard > getSP() {
        // 触发栈扩容
        morestack()
    }
}

// 栈大小计算
func stackSize(g *g) uintptr {
    return g.stack.hi - g.stack.lo
}

栈的关键特性：

  • 动态扩容: 初始 2KB，最大可达 1GB
  • 分段栈: 通过链表连接多个栈段
  • 栈收缩: 长时间未使用时自动收缩
  • 栈保护: 通过 stackguard0 检测溢出

调度上下文 gobuf​

gobuf 结构保存了 goroutine 的执行上下文，是实现协程切换的关键：

type gobuf struct {
    sp   uintptr // 栈指针 (Stack Pointer)
    pc   uintptr // 程序计数器 (Program Counter)
    g    guintptr // 指向 g 的指针
    ctxt unsafe.Pointer // 上下文指针
    ret  uintptr // 返回值
    lr   uintptr // 链接寄存器 (ARM)
    bp   uintptr // 基址指针 (Base Pointer)
}

// 上下文切换示例
func gogo(buf *gobuf) {
    // 汇编实现，恢复寄存器状态
    // 设置 SP = buf.sp
    // 设置 PC = buf.pc  
    // 跳转执行
}

func mcall(fn func(*g)) {
    // 保存当前 g 的上下文
    // 切换到 M 的系统栈
    // 调用 fn 函数
}

G 的状态转换​

Goroutine 的状态是理解调度行为的关键，状态转换反映了调度器的工作机制：

状态常量定义：

const (
    _Gidle = iota // 0: 刚分配，未初始化
    _Grunnable    // 1: 在运行队列中，等待调度
    _Grunning     // 2: 正在执行，拥有栈空间
    _Gsyscall     // 3: 正在执行系统调用
    _Gwaiting     // 4: 被阻塞，等待某个条件
    _Gdead        // 6: 执行完毕，即将被回收
    _Gcopystack   // 8: 栈正在复制，暂时不可调度
    _Gpreempted   // 9: 被抢占，等待重新调度
)

// 状态检查函数
func (g *g) isRunnable() bool {
    return readgstatus(g) == _Grunnable
}

func (g *g) isRunning() bool {
    return readgstatus(g) == _Grunning
}

状态转换的触发条件​

// 示例：不同操作导致的状态转换
func demonstrateStateTransitions() {
    // 1. Grunning -> Gwaiting (channel 操作)
    ch := make(chan int)
    go func() {
        <-ch // 当前 goroutine 进入 _Gwaiting 状态
    }()
    
    // 2. Grunning -> Gsyscall (系统调用)
    go func() {
        time.Sleep(time.Second) // 进入 _Gsyscall 状态
    }()
    
    // 3. Grunning -> Grunnable (主动让出)
    go func() {
        for i := 0; i < 1000; i++ {
            if i%100 == 0 {
                runtime.Gosched() // 主动让出，变为 _Grunnable
            }
        }
    }()
    
    // 4. Grunning -> Gdead (函数返回)
    go func() {
        fmt.Println("Hello")
        // 函数结束，goroutine 变为 _Gdead
    }()
}

G 的创建和销毁流程​

创建流程​

创建过程关键代码：

func newproc(siz int32, fn *funcval) {
    // 获取调用者信息
    argp := add(unsafe.Pointer(&fn), sys.PtrSize)
    gp := getg()
    pc := getcallerpc()
    
    // 切换到系统栈执行
    systemstack(func() {
        newg := newproc1(fn, argp, siz, gp, pc)
        // 将新 G 放入运行队列
        runqput(_p_, newg, true)
        
        // 如果有空闲的 P，尝试唤醒 M
        if mainStarted {
            wakep()
        }
    })
}

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
    _g_ := getg()
    _p_ := _g_.m.p.ptr()
    
    // 尝试从 P 的本地缓存获取
    newg := gfget(_p_)
    if newg == nil {
        // 分配新的 G
        newg = malg(_StackMin)
        casgstatus(newg, _Gidle, _Gdead)
        allgadd(newg) // 加入全局 G 列表
    }
    
    // 初始化 G
    totalSize := uintptr(narg)
    if totalSize > _StackMin-4*regSize {
        throw("newproc: function arguments too large")
    }
    
    // 设置栈空间
    sp := newg.stack.hi - totalSize
    spArg := sp
    
    // 复制参数
    if narg > 0 {
        memmove(unsafe.Pointer(spArg), argp, uintptr(narg))
    }
    
    // 初始化 gobuf
    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
    newg.sched.sp = sp
    newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum
    newg.sched.g = guintptr(unsafe.Pointer(newg))
    gostartcallfn(&newg.sched, fn)
    
    // 设置其他字段
    newg.gopc = callerpc
    newg.ancestors = saveAncestors(callergp)
    newg.startpc = fn.fn
    
    // 状态转换
    casgstatus(newg, _Gdead, _Grunnable)
    
    // 分配 goid
    if _p_.goidcache == _p_.goidcacheend {
        _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
        _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
    }
    newg.goid = int64(_p_.goidcache)
    _p_.goidcache++
    
    return newg
}

销毁流程​

销毁过程关键代码：

func goexit1() {
    _g_ := getg()
    
    // 运行所有延迟函数
    for _g_._defer != nil {
        fn := _g_._defer
        _g_._defer = fn.link
        fn.fn(fn.args)
    }
    
    // 设置状态为 dead
    casgstatus(_g_, _Grunning, _Gdead)
    
    // 清理 G
    dropg()
    
    // 将 G 放回池中复用
    gfput(_g_.m.p.ptr(), _g_)
    
    // 调度新的 G
    schedule()
}

func gfput(_p_ *p, gp *g) {
    if readgstatus(gp) != _Gdead {
        throw("gfput: bad status")
    }
    
    stksize := gp.stack.hi - gp.stack.lo
    
    if stksize != _FixedStack {
        // 栈大小异常，直接释放
        stackfree(gp.stack)
        gp.stack.lo = 0
        gp.stack.hi = 0
        gp.stackguard0 = 0
    }
    
    // 重置 G 的字段
    gp.schedlink = 0
    gp.m = nil
    gp.lockedm = 0
    gp.preempt = false
    gp.paniconfault = false
    gp._defer = nil
    gp._panic = nil
    
    // 放入本地池
    if len(_p_.gFree.stack) < 32 {
        _p_.gFree.stack[len(_p_.gFree.stack)] = gp
    } else {
        // 本地池满了，放入全局池
        lock(&sched.gFree.lock)
        sched.gFree.stack = append(sched.gFree.stack, gp)
        unlock(&sched.gFree.lock)
    }
}

G 的内存管理​

栈空间管理​

Go 的 goroutine 栈采用分段栈设计，具有以下特点：

栈管理相关函数：

// 栈扩容检查
func stackguard() {
    gp := getg()
    // 检查是否需要栈扩容
    if gp.stack.lo+_StackGuard <= getStackPointer() {
        // 触发栈扩容
        newstack()
    }
}

// 栈扩容实现
func newstack() {
    thisg := getg()
    gp := thisg.m.curg
    
    // 保存当前状态
    morebuf := thisg.m.morebuf
    thisg.m.morebuf.pc = 0
    thisg.m.morebuf.lr = 0
    thisg.m.morebuf.sp = 0
    thisg.m.morebuf.g = 0
    
    // 计算新栈大小（通常是原来的2倍）
    oldsize := gp.stack.hi - gp.stack.lo
    newsize := oldsize * 2
    
    if newsize > _MaxStack {
        throw("stack overflow")
    }
    
    // 分配新栈
    newstack := stackalloc(uint32(newsize))
    
    // 复制栈内容
    copystack(gp, newsize)
    
    // 释放旧栈
    stackfree(oldstack)
    
    // 更新栈信息
    gp.stack = newstack
    gp.stackguard0 = newstack.lo + _StackGuard
}

G 池化机制​

为了减少频繁的内存分配，Go 实现了 G 的池化复用：

池化实现代码：

// 从池中获取 G
func gfget(_p_ *p) *g {
    // 首先尝试从本地池获取
    if len(_p_.gFree.stack) > 0 {
        gp := _p_.gFree.stack[len(_p_.gFree.stack)-1]
        _p_.gFree.stack = _p_.gFree.stack[:len(_p_.gFree.stack)-1]
        return gp
    }
    
    // 本地池为空，尝试从全局池获取
    if sched.gFree.stack != nil {
        lock(&sched.gFree.lock)
        for len(_p_.gFree.stack) < 32 && len(sched.gFree.stack) > 0 {
            gp := sched.gFree.stack[len(sched.gFree.stack)-1]
            sched.gFree.stack = sched.gFree.stack[:len(sched.gFree.stack)-1]
            _p_.gFree.stack = append(_p_.gFree.stack, gp)
        }
        unlock(&sched.gFree.lock)
        
        if len(_p_.gFree.stack) > 0 {
            gp := _p_.gFree.stack[len(_p_.gFree.stack)-1]
            _p_.gFree.stack = _p_.gFree.stack[:len(_p_.gFree.stack)-1]
            return gp
        }
    }
    
    return nil
}

// 监控 G 池使用情况
func printGPoolStats() {
    for i := 0; i < runtime.GOMAXPROCS(0); i++ {
        p := runtime_getP(i)
        fmt.Printf("P%d: 本地G池大小=%d\n", i, len(p.gFree.stack))
    }
    
    fmt.Printf("全局G池大小=%d\n", len(sched.gFree.stack))
}

性能监控和调试​

G 相关的性能指标​

// 获取 Goroutine 运行时统计信息
func getGoroutineStats() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    
    fmt.Printf("当前 Goroutine 数量: %d\n", runtime.NumGoroutine())
    fmt.Printf("累计创建的 Goroutine: %d\n", m.NumGC) // 近似值
    
    // 打印所有 Goroutine 的堆栈
    buf := make([]byte, 1<<20) // 1MB buffer
    stackSize := runtime.Stack(buf, true)
    fmt.Printf("所有 Goroutine 堆栈:\n%s\n", buf[:stackSize])
}

// 监控 Goroutine 泄露
func detectGoroutineLeak() {
    initial := runtime.NumGoroutine()
    
    // 执行可能泄露的代码
    for i := 0; i < 100; i++ {
        go func() {
            select {} // 永远阻塞，模拟泄露
        }()
    }
    
    time.Sleep(time.Second)
    final := runtime.NumGoroutine()
    
    if final > initial+10 { // 允许一些正常的fluctuation
        fmt.Printf("可能存在 Goroutine 泄露: %d -> %d\n", initial, final)
    }
}

使用 pprof 分析 Goroutine​

func enableGoroutineProfiling() {
    // 启动 pprof HTTP 服务器
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    
    // 或者直接导出 goroutine profile
    f, err := os.Create("goroutine.prof")
    if err != nil {
        panic(err)
    }
    defer f.Close()
    
    pprof.Lookup("goroutine").WriteTo(f, 0)
}

分析命令：

# 查看 goroutine 信息
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 生成 goroutine 图表
go tool pprof -png http://localhost:6060/debug/pprof/goroutine > goroutines.png

# 分析阻塞的 goroutine
go tool pprof http://localhost:6060/debug/pprof/block

通过深入理解 G 的数据结构，我们可以：

  • 更好地理解 Go 的并发模型
  • 优化 goroutine 的使用模式
  • 识别和解决性能问题
  • 避免 goroutine 泄露
  • 合理设计并发程序的架构

G 的设计体现了 Go 语言"简单、高效、并发"的设计哲学，其轻量级的特性使得创建数百万个 goroutine 成为可能，这是 Go 并发编程能力的重要基础。

编辑此页
最后由 alsritter.mac 于 更新